Quick Intro to R Notebooks and R Markdown

This is an R Markdown Notebook. It combines markdown, a plain text formatting syntax, and R code. When you execute R code within the notebook, the output appears beneath the code.

This file was created in RStudio by going to File…New File…R Notebook.

R code needs to be in “chunks” for it to work. Below is an example of an R code chunk. It makes a parabola using base R graphics (not ggplot2).

Try executing this chunk by clicking the Run button within the chunk or by placing your cursor inside it and pressing Ctrl+Shift+Enter (Win/Linux) or Cmd+Shift+Return (Mac).

x <- seq(-1, 1, by = 0.01)
y <- x^2
plot(x, yy, type = "l")

To hide the output, click the Expand/Collapse output button. To clear results (or an error), click the “x”.

You can also press Ctrl+Enter (Win/Linux) or Cmd+Return (Mac) to run one line of code at a time (instead of the entire chunk).

Add a new R code chunk by clicking the Insert Chunk button on the toolbar or by pressing Ctrl+Alt+I (Win/Linux) or Cmd+Option+I (Mac).

Exercise 0 (code along)

Insert a new R code chunk below and type/run the code: 22/7

Import data

Let’s import some data which we’ll visualize today using ggplot2. The data we’ll work with is Albemarle County real estate data which was downloaded from the Office of Geographic Data Services. We’ll use a random sample of the data.

homes <- readRDS("data/homes.Rds")

cannot open compressed file 'data/homes.Rds', probable reason 'No such file or directory'Error in gzfile(file, "rb") : cannot open the connection

Let’s look at the first few rows:

head(homes)

Variable name definitions:

Intro to ggplot2

The ggplot2 package implements The Grammar of Graphics as defined in the book of the same name by Leland Wilkinson.

It requires your data be in a data frame or tibble.

Let’s do a quick example. How does the total value of a home relate to its size in finished square feet? Plot totalvalue versus finsqft to create a scatter plot.

First we need to load the ggplot2 package, which we can do with library(tidyverse). Only do this once per R session.

What just happened?

Don’t forget the parentheses on geom_point()!

Most of what we do with ggplot2 takes this general form

ggplot(data) +
  aes() +
  geom_something()

It can get much more complicated, but for exploratory visualization this often sufficient.

Exercise 1 (code along)

Do younger (more recently built) houses have a tendency to be bigger than older houses? Create a scatterplot of finsqft (y-axis) versus age (x-axis). Reminder: Insert a new code chunk by pressing Ctrl+Alt+I (Win/Linux) or Cmd+Option+I (Mac). Try entering alpha = 1/5 in geom_point(). What does it do?

More aesthetics and facets

Points not only have positions in a plane, but can be different sizes and have different shapes and colors. We can map variables in our data frame to these aesthetics.

How does the relationship between totalvalue and finsqft differ between homes with and without central air?

Plot totalvalue versus finsqft to create a scatter plot, but also color the points according to whether or not the homes have central air (cooling).

We can also map the size of the points to a variable, such as lotsize. Notice I have mapped the shape of the point to cooling.

Notice the overplotting. Perhaps we prefer to see separate scatterplots for each cooling category. We can achieve that with facets. The function to use is facet_wrap() with the variable that we want to facet on. In this case it’s cooling. Notice we precede the variable with a tilde ~. We can read that as “facet by cooling”

We can also have multiple geoms in a plot. Let’s say we want to add a smooth trend line that summarizes the relationship between finsqft and totalvalue:

Exercise 2

How is totalvalue related to lotsize within each high school district?

Create a scatterplot of totalvalue (y-axis) vs lotsize (x-axis), faceted by hsdistrict. Add smooth trend lines to summarize the relationship.

Zooming in on data

Albemarle county has homes with very large totalvalue and lotsize values. Including them in our plots means we “zoom out” to accommodate them which means we’re “far away” from the majority of homes.

To zoom in on data with ggplot2, we use the coord_cartesion() function and define the limits to view with the xlim and/or ylim arguments. Below we zoom in on the y-axis only.

Probably a good idea to tell your audience that your plot is zoomed in and looking at a subset of your data.

The numbers are a little hard to read on the y-axis. We can format them as dollar amounts using the labels argument in the scale_y_continuous() function. To do this we need to load the scales package, which is installed when you install the ggplot2 package.

Exercise 3

Modify your code from Exercise 2 to zoom in on the y-axis to see home prices ranging from 0 to $1,000,000, and zoom in on the x-axis to view homes on lots ranging in size from 0 to 5 acres. Also use the dollar function to format the home prices on the y-axis.

Visualizing counts

Recall the condition variable. We can quickly get counts of each condition using the table function:

One way to visualize counts is with a bar plot. We can create a bar plot in ggplot2 with geom_bar(). Notice it automatically generates the counts for us.

One of the aesthetics of bars is their “fill” color. We can map a variable from our data frame to the fill aesthetic. For example, let’s see counts of conditions for homes with and without central air (cooling).

The default result is to stack the bars. We can set them side-by-side setting the position argument to “dodge”.

The large number of Average homes makes it difficult to see the counts for the other categories. We could use coord_cartesian() to zoom in on the y-axis. An alternative approach is to view the proportion of homes with and without central air within each condition. We can do this by setting the position argument to “fill”.

The y-axis indicates proportions instead of counts. Only about 10% of homes in the substandard condition have central air.

Exercise 4

Given a home’s condition, is it more likely to be in a particular high school district? For example, given all the homes in Excellent condition, is there a higher proportion of them in one of the high school districts?

Create a bar plot of condition (condition on x-axis), filled by hsdistrict. Set position = ‘fill’ so we visualize within each condition the proportion belonging to a high school district.

Numeric values vs groups

How does the totalvalue of homes differ between elementary school districts? One way to visualize this is with a boxplot. We can do this with geom_boxplot.

The x-axis is hard to read. This happens sometimes. One solution is to simply rotate the plot. We can do that with the coord_flip() function. The coord_flip() function also allows us to zoom in on a plot with the xlim and ylim arguments. Let’s zoom in on the y-axis and look at homes less than 2 million in totalvalue.

A similar plot is the violin plot, which allows us to compare the distributions between categories using smooth density plots. Use geom_violin()

Boxplots and violin plots obscure the total number within in each group. That’s not necessarily a bad thing. Too much information in a plot can be overwhelming. However we could create a 1-dimensional scatterplot, sometimes called a “stripchart”. The position_jitter functions adds a little random noise to data to help spread them out.

Exercise 5

How are the ages of homes distributed between the elementary school districts? Are there some elementary schools that serve mostly newer homes? Create a boxplot of age of home by esdistrict.

Line plots over time

How many homes have been built each year in Albemarle county? What year saw the most homes built? We can use the yearbuilt variable in our data to help answer this. We just need to count up the number of homes per yearbuilt and save the result as a data frame. We’ll use what we learned in the last session to do this.

Let’s plot n vs yearbuilt using a line.

There was a boom sometime after 1750. Which year was it? Around 1950 it seems the number of homes built per year really started to take off. When was the peak? It also looks like we saw a dip sometime after 2000. What year was that?

The above plot shows some interesting trends and events, but it’s hard to get precise years and numbers. Fortunately there are ways to make ggplot graphs interactive. Here’s one way using the plotly package. Simply call ggplotly() immediately after your ggplot code:

Now we can interact with the plot to see information of interest. Hovering over points reveals precise information. We can also zoom in on portions of the plot. (Double-click in the plotting region to return to the full plot.)

plotly is package that allows you to make interactive web graphics.

How has lotsize changed over time? Let’s plot median lotsize by yearbuilt versus yearbuilt. Again we need to make a new data frame that contains yearbuilt and median lotsize per year.

After around 1900 it looks most new homes are built on small lots.

Let’s make the plot interactive. This time we save the plot and then call ggplotly on the saved object

Exercise 6

How has the mean number of fullbaths in a home changed over time (yearbuilt), since 1950? (Of course a home built with 1 bathroom in 1950 may not still have just 1 bathroom…)

The following code creates a data frame of mean fullbath by yearbuilt for 1950 to present.

Create a line plot showing how the mean number of fullbaths has changed over time (yearbuilt). Try using ggplotly().

ggplotly()

`geom_smooth()` using method = 'loess' and formula 'y ~ x'

A package that extends ggplot2: ggridges

There are many packages that extend ggplot, mainly by adding additional geoms or themes. One that is useful for our data is the ggridges package.

First notice the challenge of making comparisons of density histograms between 20 census tracts. (Census tracts are small subdivisions of a county that are used by the USA Census Bureau for statistical reporting.)

The ggridges package allows us to create ridgeline plots, which are density plots arranged in a staggered fashion. Notice the new geom geom_density_ridges().

The ggridges package provides a custom theme specifically for use with ridgeline plots. Just tack on the function theme_ridges() to use it.

We can reorder the levels of censustract by a summary statistic such as the median of totalvalue. Notice we use the base R function reorder to accomplish this. That will produce a ridgeline plot where the distributions are ordered by median totalvalue of each census tract.

NOTE: ggplotly doesn’t work with plots made by ggridges.

Creating maps in ggplot2

When we talk about real estate and census tracts, it’s natural to want to see visualizations that incorporate maps. Where is census tract 110 in Albemarle county? How big is it geographically?

To create maps we usually need latitude and longitude values so we an draw shapes, like the borders of counties, states and census tracts. Our data doesn’t have that information so we need to get it. Fortunately there is an R package that helps us quickly get this data. The tigris package allows us to download TIGER/Line shapefiles from the United States Census Bureau and load into R as “sf” objects. SF stands for “simple features” which is standardized way of encoding spatial vector data in computers.

The ggplot2 package has geoms for “sf” objects to help us easily render a map. Let’s draw a map of Albemarle county with census tract borders. First we use the tigris package to download the shapefile data using the tracts function. We save the data as an object called “alb” and draw a map using geom_sf. The theme_void function removes the grid points and background.

That’s nice but it would help if the census tracts were labeled. We can do that with geom_sf_text. We need to map the NAME column of the alb data frame to the label aesthetic.

Now we can see most of the labels, but there’s still some overplotting. It would be nice if we could zoom in on the map. Let’s make the map interactive using the ggplotly function. Click and drag within the map to zoom in on a region.

ggplotly()

st_point_on_surface may not give correct results for longitude/latitude data

We can shade the census tract regions according to a summary statistic such as median total value of a home. Let’s do that! First we calculate median totalvalue by census tract, and then merge into the alb data frame.

To shade the census tract regions we set the fill aesthetic to totalvalue. Hover over the census tract label to see the exact median home value.

ggplotly()

st_point_on_surface may not give correct results for longitude/latitude data

Wrap up

We just covered the basics of ggplot2 today. The way to get better at using ggplot2 is to keep using it and Googling for help when you get stuck.

Two more topics worth mentioning:

  1. Changing the appearance of plots
  2. Saving plots as jpg, png, tif, etc.

The appearance of plots are dictated by themes. Some different themes are included with ggplot2. For example, theme_minimal(). Simply tack it on to the end of a plot.

There are whole R packages that provided nothing but more themes for ggplot2. For example, see the ggthemes package.

Saving plots can be done with the ggsave() function. By default, it will save the last plot you created as a 7 in. x 7 in. image.

ggsave("es_lotsize.png")

ggsave() can also be tacked on to the end of ggplot code.

ggplot(homes) +
  aes(x = esdistrict, y = lotsize) +
  geom_point(position = position_jitter(width = 0.1, height = 0)) +
  coord_flip(ylim = c(0,50)) +
  theme_minimal() +
  ggsave("es_lotsize.jpeg", width = 20, height = 20, units = "cm")

When working in an R script (as opposed to an Rmd file), plots appear in the Plot frame within RStudio which provides a convenient Export button to interactively save plots.

We’re done!

If you would like to talk more about ggplot2 or anything else statistics related, I would love to hear from you: jcf2d@virginia.edu or statlab@virginia.edu

Want more ggplot2? Google getting started with ggplot2 or ggplot2 tutorial. Also see the numerous examples provided with the ggplot2 documentation.

References

ggplot2 cheat sheet
https://github.com/rstudio/cheatsheets/raw/master/data-visualization-2.1.pdf

---
title: "Data Visualization in R with ggplot2"
author: "Clay Ford, Statistical Research Consultant, UVA Library"
output: html_notebook
editor_options: 
  chunk_output_type: inline
---

## Quick Intro to R Notebooks and R Markdown

This is an R Markdown Notebook. It combines markdown, a plain text formatting syntax, and R code. When you execute R code within the notebook, the output appears beneath the code.

This file was created in RStudio by going to File...New File...R Notebook.

R code needs to be in "chunks" for it to work. Below is an example of an R code chunk. It makes a parabola using base R graphics (not ggplot2).

Try executing this chunk by clicking the *Run* button within the chunk or by placing your cursor inside it and pressing *Ctrl+Shift+Enter* (Win/Linux) or *Cmd+Shift+Return* (Mac).

```{r}
x <- seq(-1, 1, by = 0.01)
y <- x^2
plot(x, yy, type = "l")
```

To hide the output, click the Expand/Collapse output button. To clear results (or an error), click the "x".

You can also press *Ctrl+Enter* (Win/Linux) or *Cmd+Return* (Mac) to run one line of code at a time (instead of the entire chunk).

Add a new R code chunk by clicking the *Insert Chunk* button on the toolbar or by pressing *Ctrl+Alt+I* (Win/Linux) or *Cmd+Option+I* (Mac).

## Exercise 0 (code along)

Insert a new R code chunk below and type/run the code: 22/7


## Import data

Let's import some data which we'll visualize today using ggplot2. The data we'll work with is Albemarle County real estate data which was downloaded from the Office of Geographic Data Services. We'll use a random sample of the data.

```{r}
URL <- "https://github.com/uvastatlab/phdplus2020/raw/master/data/homes.rds"
homes <- readRDS("../data/homes.rds")

```

Let's look at the first few rows:

```{r}
head(homes)
```

Variable name definitions:

-   *yearbuilt*: year house was built
-   *finsqft*: size of house in number square feet
-   *cooling*: 'Central Air' versus 'No Central Air'
-   *bedroom*: number of bedrooms
-   *fullbath*: number of full bathrooms (toilet, sink and bath)
-   *halfbath*: number of half bathrooms (toilet and sink only)
-   *lotsize*: size of land on which home is located, in acres
-   *totalvalue*: total assessed value of home and property
-   *esdistrict*: the elementary school the home feeds into
-   *msdistrict*: the middle school the home feeds into
-   *hsdistrict*: the high school the home feeds into
-   *censustract*: the census tract the home is located in
-   *age*: of the house in years as of 2018
-   *condition*: assessed condition of home (Substandard, Poor, Fair, Average, Good, Excellent)
-   *remodel*: indicator if house has been remodeled (0=no, 1=yes)
-   *fp*: indicator if house has fireplace (0=no, 1=yes)

## Intro to ggplot2

The ggplot2 package implements *The Grammar of Graphics* as defined in the book of the same name by Leland Wilkinson.

It requires your data be in a data frame or tibble.

Let's do a quick example. How does the total value of a home relate to its size in finished square feet? Plot totalvalue versus finsqft to create a scatter plot.

First we need to load the ggplot2 package, which we can do with `library(tidyverse)`. Only do this once per R session.

```{r}
library(tidyverse) # loads ggplot2 and 7 other packages
ggplot(homes) +
  aes(x = finsqft, y = totalvalue) +
  geom_point() 
```

What just happened?

-   The `ggplot` function creates a plotting area for a data frame
-   The `aes` function maps variables in the data frame to aesthetic properties of geometric shapes
-   The `geom_point` function specifies we want to use points
-   combine these functions with `+`, which adds components to a plot

Don't forget the parentheses on `geom_point()`!

*Most of what we do with ggplot2 takes this general form*

    ggplot(data) +
      aes() +
      geom_something()

It can get much more complicated, but for exploratory visualization this often sufficient.

## Exercise 1 (code along)

Do younger (more recently built) houses have a tendency to be bigger than older houses? Create a scatterplot of finsqft (y-axis) versus age (x-axis). Reminder: Insert a new code chunk by pressing *Ctrl+Alt+I* (Win/Linux) or *Cmd+Option+I* (Mac). Try entering `alpha = 1/5` in `geom_point()`. What does it do?

```{r}
ggplot(homes) +
  aes(x = age, y = finsqft) +
  geom_point(alpha = 1/5)
```


## More aesthetics and facets

Points not only have positions in a plane, but can be different sizes and have different shapes and colors. We can map variables in our data frame to these aesthetics.

How does the relationship between totalvalue and finsqft differ between homes with and without central air?

Plot totalvalue versus finsqft to create a scatter plot, but also color the points according to whether or not the homes have central air (cooling).

```{r}
ggplot(homes) +
  aes(x = finsqft, y = totalvalue, color = cooling) +
  geom_point() 
```

We can also map the size of the points to a variable, such as lotsize. Notice I have mapped the shape of the point to cooling.

```{r}
ggplot(homes) +
  aes(x = finsqft, y = totalvalue, shape = cooling, size = lotsize) +
  geom_point() 

```

Notice the overplotting. Perhaps we prefer to see separate scatterplots for each cooling category. We can achieve that with *facets*. The function to use is `facet_wrap()` with the variable that we want to facet on. In this case it's cooling. Notice we precede the variable with a tilde `~`. We can read that as "facet by cooling"

```{r}
ggplot(homes) +
  aes(x = finsqft, y = totalvalue, size = lotsize) +
  geom_point(alpha = 1/2) +
  facet_wrap(~ cooling)

```

We can also have multiple geoms in a plot. Let's say we want to add a smooth trend line that summarizes the relationship between finsqft and totalvalue:

```{r}
ggplot(homes) +
  aes(x = finsqft, y = totalvalue) +
  geom_point(alpha = 1/2) +
  geom_smooth() +
  facet_wrap(~ cooling) 

```

## Exercise 2

How is totalvalue related to lotsize within each high school district?

Create a scatterplot of totalvalue (y-axis) vs lotsize (x-axis), faceted by hsdistrict. Add smooth trend lines to summarize the relationship.

```{r}
ggplot(homes) +
  aes(x = lotsize, y = totalvalue) +
  geom_point() +
  geom_smooth() +
  facet_wrap(~hsdistrict)
```


### Zooming in on data

Albemarle county has homes with very large totalvalue and lotsize values. Including them in our plots means we "zoom out" to accommodate them which means we're "far away" from the majority of homes.

To zoom in on data with ggplot2, we use the `coord_cartesion()` function and define the limits to view with the `xlim` and/or `ylim` arguments. Below we zoom in on the y-axis only.

```{r}
ggplot(homes) +
  aes(x = finsqft, y = totalvalue) +
  geom_point() +
  geom_smooth() + 
  coord_cartesian(xlim = c(0,5000), 
                  ylim = c(0, 2e6)) # from 0 to $2,000,000

```
Probably a good idea to tell your audience that your plot is zoomed in and looking at a subset of your data.

The numbers are a little hard to read on the y-axis. We can format them as dollar amounts using the labels argument in the `scale_y_continuous()` function. To do this we need to load the scales package, which is installed when you install the ggplot2 package.

```{r}
library(scales) # for the dollar function
ggplot(homes) +
  aes(x = finsqft, y = totalvalue) +
  geom_point() +
  geom_smooth() +
  coord_cartesian(ylim = c(0, 2e6)) + 
  scale_y_continuous(labels=dollar) 

```

## Exercise 3

Modify your code from Exercise 2 to zoom in on the y-axis to see home prices ranging from 0 to `$1,000,000`, and zoom in on the x-axis to view homes on lots ranging in size from 0 to 5 acres. Also use the dollar function to format the home prices on the y-axis.

```{r}
ggplot(homes) +
  aes(x = lotsize, y = totalvalue) +
  geom_point() +
  geom_smooth() +
  facet_wrap(~ hsdistrict)  +
  coord_cartesian(xlim = c(0,5), ylim = c(0,1e6)) +
  scale_y_continuous(labels = dollar)

```

## Visualizing counts

Recall the condition variable. We can quickly get counts of each condition using the table function:

```{r}
homes %>% count(condition)
```

One way to visualize counts is with a bar plot. We can create a bar plot in ggplot2 with `geom_bar()`. Notice it automatically generates the counts for us.

```{r}
ggplot(homes) +
  aes(x = condition) +
  geom_bar()
```

One of the aesthetics of bars is their "fill" color. We can map a variable from our data frame to the fill aesthetic. For example, let's see counts of conditions for homes with and without central air (cooling).

```{r}
ggplot(homes) +
  aes(x = condition, fill = cooling) +
  geom_bar()

```

The default result is to stack the bars. We can set them side-by-side setting the position argument to "dodge".

```{r}
ggplot(homes) +
  aes(x = condition, fill = cooling) +
  geom_bar(position = "dodge") 

```

The large number of Average homes makes it difficult to see the counts for the other categories. We could use `coord_cartesian()` to zoom in on the y-axis. An alternative approach is to view the proportion of homes with and without central air within each condition. We can do this by setting the position argument to "fill".

```{r}
ggplot(homes) +
  aes(x = condition, fill = cooling) +
  geom_bar(position = "fill")

```

The y-axis indicates proportions instead of counts. Only about 10% of homes in the substandard condition have central air.

## Exercise 4

Given a home's condition, is it more likely to be in a particular high school district? For example, given all the homes in Excellent condition, is there a higher proportion of them in one of the high school districts?

Create a bar plot of condition (condition on x-axis), filled by hsdistrict. Set position = 'fill' so we visualize within each condition the proportion belonging to a high school district.

```{r}
ggplot(homes) +
  aes(x = condition, fill = hsdistrict) +
  geom_bar(position = "fill") +
  ylab("Proportion")
```


## Numeric values vs groups

How does the totalvalue of homes differ between elementary school districts? One way to visualize this is with a boxplot. We can do this with `geom_boxplot`.

```{r}
ggplot(homes) +
  aes(x = esdistrict, y = totalvalue) +
  geom_boxplot()
```

The x-axis is hard to read. This happens sometimes. One solution is to simply rotate the plot. We can do that with the `coord_flip()` function. The `coord_flip()` function also allows us to zoom in on a plot with the xlim and ylim arguments. Let's zoom in on the y-axis and look at homes less than 2 million in totalvalue.

```{r}
ggplot(homes) +
  aes(x = esdistrict, y = totalvalue) +
  geom_boxplot() +
  coord_flip(ylim = c(0,2e6))

```

-   The width of the box (along the y axis) represents the middle 50% of the data. It is called the Interquartile Range (IQR).
-   The line in the box is the median.
-   The top of the box is the 75th percentile.
-   The bottom of the box is the 25th percentile.
-   The "whiskers" extending out of the box are to the highest and lowest values not to exceed 1.5 \* IQR
-   The dots are considered "outliers" relative to the rest of the data.

A similar plot is the violin plot, which allows us to compare the distributions between categories using smooth density plots. Use `geom_violin()`

```{r}
ggplot(homes) +
  aes(x = esdistrict, y = totalvalue) +
  geom_violin() +
  coord_flip(ylim = c(0,1e6))
```

Boxplots and violin plots obscure the total number within in each group. That's not necessarily a bad thing. Too much information in a plot can be overwhelming. However we could create a 1-dimensional scatterplot, sometimes called a "stripchart". The `position_jitter` functions adds a little random noise to data to help spread them out.

```{r}
ggplot(homes) +
  aes(x = esdistrict, y = totalvalue) +
  geom_point(position = position_jitter(width = 0.2, height = 0),
             alpha = 1/6) +
  coord_flip(ylim = c(0,1e6))

```

## Exercise 5

How are the ages of homes distributed between the elementary school districts? Are there some elementary schools that serve mostly newer homes? Create a boxplot of age of home by esdistrict.

```{r}
ggplot(homes) +
  aes(x = esdistrict, y = age) +
  geom_boxplot() +
  coord_flip()
```


## Line plots over time

How many homes have been built each year in Albemarle county? What year saw the most homes built? We can use the yearbuilt variable in our data to help answer this. We just need to count up the number of homes per yearbuilt and save the result as a data frame. We'll use what we learned in the last session to do this. 

```{r}
homes_year <- homes %>%  
  count(yearbuilt) 
tail(homes_year, n = 10)
```

Let's plot n vs yearbuilt using a line.

```{r}
ggplot(homes_year) +
  aes(x = yearbuilt, y = n) +
  geom_line()
```

There was a boom sometime after 1750. Which year was it? Around 1950 it seems the number of homes built per year really started to take off. When was the peak? It also looks like we saw a dip sometime after 2000. What year was that?

The above plot shows some interesting trends and events, but it's hard to get precise years and numbers. Fortunately there are ways to make ggplot graphs interactive. Here's one way using the plotly package. Simply call `ggplotly()` immediately after your ggplot code:

```{r}
library(plotly)
ggplot(homes_year) +
  aes(x = yearbuilt, y = n) +
  geom_line()
ggplotly()
```

Now we can interact with the plot to see information of interest. Hovering over points reveals precise information. We can also zoom in on portions of the plot. (Double-click in the plotting region to return to the full plot.)

plotly is package that allows you to make interactive web graphics.  

How has lotsize changed over time? Let's plot median lotsize by yearbuilt versus yearbuilt. Again we need to make a new data frame that contains yearbuilt and median lotsize per year.

```{r}
homes_median_lotsize <- homes %>% 
  group_by(yearbuilt) %>% 
  summarize(lotsize = median(lotsize))

ggplot(homes_median_lotsize) +
  aes(x = yearbuilt, y = lotsize) +
  geom_line() 
```

After around 1900 it looks most new homes are built on small lots.

Let's make the plot interactive. This time we save the plot and then call `ggplotly` on the saved object

```{r}
p <- ggplot(homes_median_lotsize) +
  aes(x = yearbuilt, y = lotsize) +
  geom_line() 
ggplotly(p)

```

## Exercise 6

How has the mean number of fullbaths in a home changed over time (yearbuilt), since 1950? (Of course a home built with 1 bathroom in 1950 may not still have just 1 bathroom...)

The following code creates a data frame of mean fullbath by yearbuilt for 1950 to present.

```{r}
homes_mean_fb <- homes %>% 
  filter(yearbuilt >= 1950) %>% 
  group_by(yearbuilt) %>% 
  summarize(fullbath = mean(fullbath))
  
head(homes_mean_fb)
```

Create a line plot showing how the mean number of fullbaths has changed over time (yearbuilt). Try using `ggplotly()`.

```{r}
ggplot(homes_mean_fb) +
  aes(x = yearbuilt, y = fullbath) +
  geom_line() +
  geom_smooth()
ggplotly()
```



## A package that extends ggplot2: ggridges

There are many packages that extend ggplot, mainly by adding additional geoms or themes. One that is useful for our data is the ggridges package.

First notice the challenge of making comparisons of density histograms between 20 census tracts. (Census tracts are small subdivisions of a county that are used by the USA Census Bureau for statistical reporting.)

```{r}
ggplot(homes) +
  aes(x = totalvalue) +
  geom_density() +
  facet_wrap(~censustract) +
  coord_cartesian(xlim = c(0, 1e6))

```

The ggridges package allows us to create ridgeline plots, which are density plots arranged in a staggered fashion. Notice the new geom `geom_density_ridges()`.

```{r}
library(ggridges)
ggplot(homes) +
  aes(x = totalvalue, y = censustract) + 
  geom_density_ridges() +
  coord_cartesian(xlim = c(0, 1e6))

```


The ggridges package provides a custom theme specifically for use with ridgeline plots. Just tack on the function `theme_ridges()` to use it.

```{r}
ggplot(homes) +
  aes(x = totalvalue, y = factor(censustract)) + 
  geom_density_ridges() +
  coord_cartesian(xlim = c(0, 1e6)) +
  theme_ridges()

```


We can reorder the levels of censustract by a summary statistic such as the median of totalvalue. Notice we use the base R function `reorder` to accomplish this. That will produce a ridgeline plot where the  distributions are ordered by median totalvalue of each census tract.

```{r}
ggplot(homes) +
  aes(x = totalvalue, y = reorder(censustract, totalvalue, median)) + 
  geom_density_ridges() +
  coord_cartesian(xlim = c(0, 1e6)) +
  scale_x_continuous(labels = scales::dollar) +
  labs(y = "Census Tract", x = "Total Value", 
       title = "Distribution of Total Value by Census Tract") +
  theme_ridges()

```

NOTE: `ggplotly` doesn't work with plots made by ggridges.

## Creating maps in ggplot2

When we talk about real estate and census tracts, it's natural to want to see visualizations that incorporate maps. Where is census tract 110 in Albemarle county? How big is it geographically?

To create maps we usually need latitude and longitude values so we an draw shapes, like the borders of counties, states and census tracts. Our data doesn't have that information so we need to get it. Fortunately there is an R package that helps us quickly get this data. The tigris package allows us to download TIGER/Line shapefiles from the United States Census Bureau and load into R as "sf" objects. SF stands for "simple features" which is standardized way of encoding spatial vector data in computers.

The ggplot2 package has geoms for "sf" objects to help us easily render a map. Let's draw a map of Albemarle county with census tract borders. First we use the tigris package to download the shapefile data using the `tracts` function. We save the data as an object called "alb" and draw a map using `geom_sf`. The `theme_void` function removes the grid points and background.


```{r}
library(tigris)

# this is going to download about 15 MB of data; may take a second
alb <- tracts(state = "VA", county = "Albemarle")

ggplot(alb) +
  geom_sf(color = "red") +
  theme_void() 
```


That's nice but it would help if the census tracts were labeled. We can do that with `geom_sf_text`. We need to map the NAME column of the alb data frame to the label aesthetic.

```{r}
ggplot(alb) +
  aes(label = NAME) +
  geom_sf(color = "red") +
  geom_sf_text(size = 3) + # size = 3 makes text smaller
  theme_void() 
```

Now we can see most of the labels, but there's still some overplotting. It would be nice if we could zoom in on the map. Let's make the map interactive using the `ggplotly` function. Click and drag within the map to zoom in on a region.

```{r}
ggplot(alb) +
  aes(label = NAME) +
  geom_sf(color = "red") +
  geom_sf_text(size = 3) +
  theme_void()
ggplotly()
```


We can shade the census tract regions according to a summary statistic such as median total value of a home. Let's do that! First we calculate median totalvalue by census tract, and then merge into the alb data frame.


```{r}
med_tv <- homes %>%
  group_by(censustract) %>% 
  summarize(totalvalue = median(totalvalue))

alb <- left_join(alb, med_tv, by = c("NAME" = "censustract"))

```

To shade the census tract regions we set the fill aesthetic to totalvalue. Hover over the census tract label to see the exact median home value.

```{r}
ggplot(alb) +
  aes(fill = totalvalue, label = NAME) +
  geom_sf(color = "red") +
  geom_sf_text(size = 3) +
  scale_fill_continuous("Median home value", 
                        labels = dollar) +
  theme_void()
ggplotly()

```



## Wrap up

We just covered the basics of ggplot2 today. The way to get better at using ggplot2 is to keep using it and Googling for help when you get stuck.

Two more topics worth mentioning:

1.  Changing the appearance of plots
2.  Saving plots as jpg, png, tif, etc.

The appearance of plots are dictated by themes. Some different themes are included with ggplot2. For example, `theme_minimal()`. Simply tack it on to the end of a plot.

```{r}
ggplot(homes) +
  aes(x = esdistrict, y = lotsize) +
  geom_point(position = position_jitter(width = 0.1, height = 0)) +
  coord_flip(ylim = c(0,50)) +
  theme_minimal()
```

There are whole R packages that provided nothing but more themes for ggplot2. For example, see the `ggthemes` package.

Saving plots can be done with the `ggsave()` function. By default, it will save the last plot you created as a 7 in. x 7 in. image.

```{r}
ggsave("es_lotsize.png")
```

`ggsave()` can also be tacked on to the end of ggplot code.

```{r}
ggplot(homes) +
  aes(x = esdistrict, y = lotsize) +
  geom_point(position = position_jitter(width = 0.1, height = 0)) +
  coord_flip(ylim = c(0,50)) +
  theme_minimal() +
  ggsave("es_lotsize.jpeg", width = 20, height = 20, units = "cm")

```

When working in an R script (as opposed to an Rmd file), plots appear in the Plot frame within RStudio which provides a convenient Export button to interactively save plots.

## We're done!

If you would like to talk more about ggplot2 or anything else statistics related, I would love to hear from you: `jcf2d@virginia.edu` or `statlab@virginia.edu`

Want more ggplot2? Google `getting started with ggplot2` or `ggplot2 tutorial`. Also see the numerous examples provided with the ggplot2 documentation.

## References

-   Wickham, H. (2016), *ggplot2: Elegant Graphics for Data Analysis* (2nd ed), Springer. <https://ggplot2-book.org/>

-   Wickham, H. and Grolemund G. (2017), *R for Data Science*. O'Reilly. <http://r4ds.had.co.nz/>

**ggplot2 cheat sheet**\
<https://github.com/rstudio/cheatsheets/raw/master/data-visualization-2.1.pdf>
